// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.loan.now.balance;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.LoanNowBalance;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(LoanNowBalance.class)
@Setter
@Getter
public class LoanNowBalanceSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "LoanNowBalance".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("supplierName", "s");
    map.put("applicationDep", "sd");
    map.put("optUid", "su");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 指定使用特定的视图过滤条件
   * <p>
   * 有效值包括：LoanNowBalance/Alllnb, LoanNowBalance/Unpaid, LoanNowBalance/PaidOff
   * </p>
   */
  private String byViewName;

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 供应商
   */
  private Long supplierName;

  /**
   * 供应商 比较(eq)
   */
  private Long supplierNameEq;
  /**
   * 供应商 比较(neq)
   */
  private Long supplierNameNeq;
  /**
   * 供应商 比较(gt)
   */
  private Long supplierNameGt;
  /**
   * 供应商 比较(gte)
   */
  private Long supplierNameGte;
  /**
   * 供应商 比较(lt)
   */
  private Long supplierNameLt;
  /**
   * 供应商 比较(lte)
   */
  private Long supplierNameLte;
  /**
   * 供应商 比较(contains)
   */
  private Long supplierNameContains;
  /**
   * 供应商 比较(notcontains)
   */
  private Long supplierNameNotcontains;
  /**
   * 供应商 比较(startswith)
   */
  private Long supplierNameStartswith;
  /**
   * 供应商 比较(endswith)
   */
  private Long supplierNameEndswith;
  /**
   * 供应商 比较(isnull)
   */
  private Boolean supplierNameIsnull;
  /**
   * 供应商 比较(isnotnull)
   */
  private Boolean supplierNameIsnotnull;
  /**
   * 供应商的供应商简称 比较(eq)
   */
  private String supplierNameSupplierNameEq;
  /**
   * 供应商的供应商简称 比较(neq)
   */
  private String supplierNameSupplierNameNeq;
  /**
   * 供应商的供应商简称 比较(gt)
   */
  private String supplierNameSupplierNameGt;
  /**
   * 供应商的供应商简称 比较(gte)
   */
  private String supplierNameSupplierNameGte;
  /**
   * 供应商的供应商简称 比较(lt)
   */
  private String supplierNameSupplierNameLt;
  /**
   * 供应商的供应商简称 比较(lte)
   */
  private String supplierNameSupplierNameLte;
  /**
   * 供应商的供应商简称 比较(contains)
   */
  private String supplierNameSupplierNameContains;
  /**
   * 供应商的供应商简称 比较(notcontains)
   */
  private String supplierNameSupplierNameNotcontains;
  /**
   * 供应商的供应商简称 比较(startswith)
   */
  private String supplierNameSupplierNameStartswith;
  /**
   * 供应商的供应商简称 比较(endswith)
   */
  private String supplierNameSupplierNameEndswith;
  /**
   * 供应商的供应商简称 比较(isnull)
   */
  private Boolean supplierNameSupplierNameIsnull;
  /**
   * 供应商的供应商简称 比较(isnotnull)
   */
  private Boolean supplierNameSupplierNameIsnotnull;

  /**
   * 供应商(范围搜索)
   */
  private List<Long> supplierNameInList;

  /**
   * 采购单号(模糊搜索)
   */
  private String purchaseOrderCode;

  /**
   * 采购单号 比较(eq)
   */
  private String purchaseOrderCodeEq;
  /**
   * 采购单号 比较(neq)
   */
  private String purchaseOrderCodeNeq;
  /**
   * 采购单号 比较(gt)
   */
  private String purchaseOrderCodeGt;
  /**
   * 采购单号 比较(gte)
   */
  private String purchaseOrderCodeGte;
  /**
   * 采购单号 比较(lt)
   */
  private String purchaseOrderCodeLt;
  /**
   * 采购单号 比较(lte)
   */
  private String purchaseOrderCodeLte;
  /**
   * 采购单号 比较(contains)
   */
  private String purchaseOrderCodeContains;
  /**
   * 采购单号 比较(notcontains)
   */
  private String purchaseOrderCodeNotcontains;
  /**
   * 采购单号 比较(startswith)
   */
  private String purchaseOrderCodeStartswith;
  /**
   * 采购单号 比较(endswith)
   */
  private String purchaseOrderCodeEndswith;
  /**
   * 采购单号 比较(isnull)
   */
  private Boolean purchaseOrderCodeIsnull;
  /**
   * 采购单号 比较(isnotnull)
   */
  private Boolean purchaseOrderCodeIsnotnull;

  /**
   * 采购单号(精确搜索)
   */
  private List<String> purchaseOrderCodeInList;

  /**
   * 采购方
   */
  private Long applicationDep;

  /**
   * 采购方 比较(eq)
   */
  private Long applicationDepEq;
  /**
   * 采购方 比较(neq)
   */
  private Long applicationDepNeq;
  /**
   * 采购方 比较(gt)
   */
  private Long applicationDepGt;
  /**
   * 采购方 比较(gte)
   */
  private Long applicationDepGte;
  /**
   * 采购方 比较(lt)
   */
  private Long applicationDepLt;
  /**
   * 采购方 比较(lte)
   */
  private Long applicationDepLte;
  /**
   * 采购方 比较(contains)
   */
  private Long applicationDepContains;
  /**
   * 采购方 比较(notcontains)
   */
  private Long applicationDepNotcontains;
  /**
   * 采购方 比较(startswith)
   */
  private Long applicationDepStartswith;
  /**
   * 采购方 比较(endswith)
   */
  private Long applicationDepEndswith;
  /**
   * 采购方 比较(isnull)
   */
  private Boolean applicationDepIsnull;
  /**
   * 采购方 比较(isnotnull)
   */
  private Boolean applicationDepIsnotnull;
  /**
   * 采购方的部门名称 比较(eq)
   */
  private String applicationDepNameEq;
  /**
   * 采购方的部门名称 比较(neq)
   */
  private String applicationDepNameNeq;
  /**
   * 采购方的部门名称 比较(gt)
   */
  private String applicationDepNameGt;
  /**
   * 采购方的部门名称 比较(gte)
   */
  private String applicationDepNameGte;
  /**
   * 采购方的部门名称 比较(lt)
   */
  private String applicationDepNameLt;
  /**
   * 采购方的部门名称 比较(lte)
   */
  private String applicationDepNameLte;
  /**
   * 采购方的部门名称 比较(contains)
   */
  private String applicationDepNameContains;
  /**
   * 采购方的部门名称 比较(notcontains)
   */
  private String applicationDepNameNotcontains;
  /**
   * 采购方的部门名称 比较(startswith)
   */
  private String applicationDepNameStartswith;
  /**
   * 采购方的部门名称 比较(endswith)
   */
  private String applicationDepNameEndswith;
  /**
   * 采购方的部门名称 比较(isnull)
   */
  private Boolean applicationDepNameIsnull;
  /**
   * 采购方的部门名称 比较(isnotnull)
   */
  private Boolean applicationDepNameIsnotnull;

  /**
   * 采购方(范围搜索)
   */
  private List<Long> applicationDepInList;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 状态
   */
  private String status;

  /**
   * 状态 比较(eq)
   */
  private String statusEq;
  /**
   * 状态 比较(neq)
   */
  private String statusNeq;
  /**
   * 状态 比较(gt)
   */
  private String statusGt;
  /**
   * 状态 比较(gte)
   */
  private String statusGte;
  /**
   * 状态 比较(lt)
   */
  private String statusLt;
  /**
   * 状态 比较(lte)
   */
  private String statusLte;
  /**
   * 状态 比较(contains)
   */
  private String statusContains;
  /**
   * 状态 比较(notcontains)
   */
  private String statusNotcontains;
  /**
   * 状态 比较(startswith)
   */
  private String statusStartswith;
  /**
   * 状态 比较(endswith)
   */
  private String statusEndswith;
  /**
   * 状态 比较(isnull)
   */
  private Boolean statusIsnull;
  /**
   * 状态 比较(isnotnull)
   */
  private Boolean statusIsnotnull;

  /**
   * 状态(精确搜索)
   */
  private List<String> statusInList;

  /**
   * 结算描述(模糊搜索)
   */
  private String describe;

  /**
   * 结算描述 比较(eq)
   */
  private String describeEq;
  /**
   * 结算描述 比较(neq)
   */
  private String describeNeq;
  /**
   * 结算描述 比较(gt)
   */
  private String describeGt;
  /**
   * 结算描述 比较(gte)
   */
  private String describeGte;
  /**
   * 结算描述 比较(lt)
   */
  private String describeLt;
  /**
   * 结算描述 比较(lte)
   */
  private String describeLte;
  /**
   * 结算描述 比较(contains)
   */
  private String describeContains;
  /**
   * 结算描述 比较(notcontains)
   */
  private String describeNotcontains;
  /**
   * 结算描述 比较(startswith)
   */
  private String describeStartswith;
  /**
   * 结算描述 比较(endswith)
   */
  private String describeEndswith;
  /**
   * 结算描述 比较(isnull)
   */
  private Boolean describeIsnull;
  /**
   * 结算描述 比较(isnotnull)
   */
  private Boolean describeIsnotnull;

  /**
   * 结算描述(精确搜索)
   */
  private List<String> describeInList;

  /**
   * 预付比例
   */
  private java.math.BigDecimal budgetRatio;

  /**
   * 最小预付比例
   */
  private java.math.BigDecimal budgetRatioMin;

  /**
   * 最大预付比例
   */
  private java.math.BigDecimal budgetRatioMax;

  /**
   * 预付比例 比较(eq)
   */
  private java.math.BigDecimal budgetRatioEq;
  /**
   * 预付比例 比较(neq)
   */
  private java.math.BigDecimal budgetRatioNeq;
  /**
   * 预付比例 比较(gt)
   */
  private java.math.BigDecimal budgetRatioGt;
  /**
   * 预付比例 比较(gte)
   */
  private java.math.BigDecimal budgetRatioGte;
  /**
   * 预付比例 比较(lt)
   */
  private java.math.BigDecimal budgetRatioLt;
  /**
   * 预付比例 比较(lte)
   */
  private java.math.BigDecimal budgetRatioLte;
  /**
   * 预付比例 比较(contains)
   */
  private java.math.BigDecimal budgetRatioContains;
  /**
   * 预付比例 比较(notcontains)
   */
  private java.math.BigDecimal budgetRatioNotcontains;
  /**
   * 预付比例 比较(startswith)
   */
  private java.math.BigDecimal budgetRatioStartswith;
  /**
   * 预付比例 比较(endswith)
   */
  private java.math.BigDecimal budgetRatioEndswith;
  /**
   * 预付比例 比较(isnull)
   */
  private Boolean budgetRatioIsnull;
  /**
   * 预付比例 比较(isnotnull)
   */
  private Boolean budgetRatioIsnotnull;

  /**
   * 最早预计付款时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date predictFkTimeStart;

  /**
   * 最晚预计付款时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date predictFkTimeEnd;

  /**
   * 预计付款时间 比较(eq)
   */
  private Date predictFkTimeEq;
  /**
   * 预计付款时间 比较(neq)
   */
  private Date predictFkTimeNeq;
  /**
   * 预计付款时间 比较(gt)
   */
  private Date predictFkTimeGt;
  /**
   * 预计付款时间 比较(gte)
   */
  private Date predictFkTimeGte;
  /**
   * 预计付款时间 比较(lt)
   */
  private Date predictFkTimeLt;
  /**
   * 预计付款时间 比较(lte)
   */
  private Date predictFkTimeLte;
  /**
   * 预计付款时间 比较(contains)
   */
  private Date predictFkTimeContains;
  /**
   * 预计付款时间 比较(notcontains)
   */
  private Date predictFkTimeNotcontains;
  /**
   * 预计付款时间 比较(startswith)
   */
  private Date predictFkTimeStartswith;
  /**
   * 预计付款时间 比较(endswith)
   */
  private Date predictFkTimeEndswith;
  /**
   * 预计付款时间 比较(isnull)
   */
  private Boolean predictFkTimeIsnull;
  /**
   * 预计付款时间 比较(isnotnull)
   */
  private Boolean predictFkTimeIsnotnull;

  /**
   * 支付方式
   */
  private String payType;

  /**
   * 支付方式 比较(eq)
   */
  private String payTypeEq;
  /**
   * 支付方式 比较(neq)
   */
  private String payTypeNeq;
  /**
   * 支付方式 比较(gt)
   */
  private String payTypeGt;
  /**
   * 支付方式 比较(gte)
   */
  private String payTypeGte;
  /**
   * 支付方式 比较(lt)
   */
  private String payTypeLt;
  /**
   * 支付方式 比较(lte)
   */
  private String payTypeLte;
  /**
   * 支付方式 比较(contains)
   */
  private String payTypeContains;
  /**
   * 支付方式 比较(notcontains)
   */
  private String payTypeNotcontains;
  /**
   * 支付方式 比较(startswith)
   */
  private String payTypeStartswith;
  /**
   * 支付方式 比较(endswith)
   */
  private String payTypeEndswith;
  /**
   * 支付方式 比较(isnull)
   */
  private Boolean payTypeIsnull;
  /**
   * 支付方式 比较(isnotnull)
   */
  private Boolean payTypeIsnotnull;

  /**
   * 支付方式(精确搜索)
   */
  private List<String> payTypeInList;

  /**
   * 户名(模糊搜索)
   */
  private String userName;

  /**
   * 户名 比较(eq)
   */
  private String userNameEq;
  /**
   * 户名 比较(neq)
   */
  private String userNameNeq;
  /**
   * 户名 比较(gt)
   */
  private String userNameGt;
  /**
   * 户名 比较(gte)
   */
  private String userNameGte;
  /**
   * 户名 比较(lt)
   */
  private String userNameLt;
  /**
   * 户名 比较(lte)
   */
  private String userNameLte;
  /**
   * 户名 比较(contains)
   */
  private String userNameContains;
  /**
   * 户名 比较(notcontains)
   */
  private String userNameNotcontains;
  /**
   * 户名 比较(startswith)
   */
  private String userNameStartswith;
  /**
   * 户名 比较(endswith)
   */
  private String userNameEndswith;
  /**
   * 户名 比较(isnull)
   */
  private Boolean userNameIsnull;
  /**
   * 户名 比较(isnotnull)
   */
  private Boolean userNameIsnotnull;

  /**
   * 户名(精确搜索)
   */
  private List<String> userNameInList;

  /**
   * 开户行(模糊搜索)
   */
  private String bankOfDeposit;

  /**
   * 开户行 比较(eq)
   */
  private String bankOfDepositEq;
  /**
   * 开户行 比较(neq)
   */
  private String bankOfDepositNeq;
  /**
   * 开户行 比较(gt)
   */
  private String bankOfDepositGt;
  /**
   * 开户行 比较(gte)
   */
  private String bankOfDepositGte;
  /**
   * 开户行 比较(lt)
   */
  private String bankOfDepositLt;
  /**
   * 开户行 比较(lte)
   */
  private String bankOfDepositLte;
  /**
   * 开户行 比较(contains)
   */
  private String bankOfDepositContains;
  /**
   * 开户行 比较(notcontains)
   */
  private String bankOfDepositNotcontains;
  /**
   * 开户行 比较(startswith)
   */
  private String bankOfDepositStartswith;
  /**
   * 开户行 比较(endswith)
   */
  private String bankOfDepositEndswith;
  /**
   * 开户行 比较(isnull)
   */
  private Boolean bankOfDepositIsnull;
  /**
   * 开户行 比较(isnotnull)
   */
  private Boolean bankOfDepositIsnotnull;

  /**
   * 开户行(精确搜索)
   */
  private List<String> bankOfDepositInList;

  /**
   * 账号(模糊搜索)
   */
  private String account;

  /**
   * 账号 比较(eq)
   */
  private String accountEq;
  /**
   * 账号 比较(neq)
   */
  private String accountNeq;
  /**
   * 账号 比较(gt)
   */
  private String accountGt;
  /**
   * 账号 比较(gte)
   */
  private String accountGte;
  /**
   * 账号 比较(lt)
   */
  private String accountLt;
  /**
   * 账号 比较(lte)
   */
  private String accountLte;
  /**
   * 账号 比较(contains)
   */
  private String accountContains;
  /**
   * 账号 比较(notcontains)
   */
  private String accountNotcontains;
  /**
   * 账号 比较(startswith)
   */
  private String accountStartswith;
  /**
   * 账号 比较(endswith)
   */
  private String accountEndswith;
  /**
   * 账号 比较(isnull)
   */
  private Boolean accountIsnull;
  /**
   * 账号 比较(isnotnull)
   */
  private Boolean accountIsnotnull;

  /**
   * 账号(精确搜索)
   */
  private List<String> accountInList;

  /**
   * 付款币种
   */
  private String currency;

  /**
   * 付款币种 比较(eq)
   */
  private String currencyEq;
  /**
   * 付款币种 比较(neq)
   */
  private String currencyNeq;
  /**
   * 付款币种 比较(gt)
   */
  private String currencyGt;
  /**
   * 付款币种 比较(gte)
   */
  private String currencyGte;
  /**
   * 付款币种 比较(lt)
   */
  private String currencyLt;
  /**
   * 付款币种 比较(lte)
   */
  private String currencyLte;
  /**
   * 付款币种 比较(contains)
   */
  private String currencyContains;
  /**
   * 付款币种 比较(notcontains)
   */
  private String currencyNotcontains;
  /**
   * 付款币种 比较(startswith)
   */
  private String currencyStartswith;
  /**
   * 付款币种 比较(endswith)
   */
  private String currencyEndswith;
  /**
   * 付款币种 比较(isnull)
   */
  private Boolean currencyIsnull;
  /**
   * 付款币种 比较(isnotnull)
   */
  private Boolean currencyIsnotnull;

  /**
   * 付款币种(精确搜索)
   */
  private List<String> currencyInList;

  /**
   * 请款维度
   */
  private String withdrawDimension;

  /**
   * 请款维度 比较(eq)
   */
  private String withdrawDimensionEq;
  /**
   * 请款维度 比较(neq)
   */
  private String withdrawDimensionNeq;
  /**
   * 请款维度 比较(gt)
   */
  private String withdrawDimensionGt;
  /**
   * 请款维度 比较(gte)
   */
  private String withdrawDimensionGte;
  /**
   * 请款维度 比较(lt)
   */
  private String withdrawDimensionLt;
  /**
   * 请款维度 比较(lte)
   */
  private String withdrawDimensionLte;
  /**
   * 请款维度 比较(contains)
   */
  private String withdrawDimensionContains;
  /**
   * 请款维度 比较(notcontains)
   */
  private String withdrawDimensionNotcontains;
  /**
   * 请款维度 比较(startswith)
   */
  private String withdrawDimensionStartswith;
  /**
   * 请款维度 比较(endswith)
   */
  private String withdrawDimensionEndswith;
  /**
   * 请款维度 比较(isnull)
   */
  private Boolean withdrawDimensionIsnull;
  /**
   * 请款维度 比较(isnotnull)
   */
  private Boolean withdrawDimensionIsnotnull;

  /**
   * 请款维度(精确搜索)
   */
  private List<String> withdrawDimensionInList;

  /**
   * 采购量
   */
  private Integer purchaseQuantity;

  /**
   * 最小采购量
   */
  private Integer purchaseQuantityMin;

  /**
   * 最大采购量
   */
  private Integer purchaseQuantityMax;

  /**
   * 采购量 比较(eq)
   */
  private Integer purchaseQuantityEq;
  /**
   * 采购量 比较(neq)
   */
  private Integer purchaseQuantityNeq;
  /**
   * 采购量 比较(gt)
   */
  private Integer purchaseQuantityGt;
  /**
   * 采购量 比较(gte)
   */
  private Integer purchaseQuantityGte;
  /**
   * 采购量 比较(lt)
   */
  private Integer purchaseQuantityLt;
  /**
   * 采购量 比较(lte)
   */
  private Integer purchaseQuantityLte;
  /**
   * 采购量 比较(contains)
   */
  private Integer purchaseQuantityContains;
  /**
   * 采购量 比较(notcontains)
   */
  private Integer purchaseQuantityNotcontains;
  /**
   * 采购量 比较(startswith)
   */
  private Integer purchaseQuantityStartswith;
  /**
   * 采购量 比较(endswith)
   */
  private Integer purchaseQuantityEndswith;
  /**
   * 采购量 比较(isnull)
   */
  private Boolean purchaseQuantityIsnull;
  /**
   * 采购量 比较(isnotnull)
   */
  private Boolean purchaseQuantityIsnotnull;

  /**
   * 到货量
   */
  private Integer quantityReceived;

  /**
   * 最小到货量
   */
  private Integer quantityReceivedMin;

  /**
   * 最大到货量
   */
  private Integer quantityReceivedMax;

  /**
   * 到货量 比较(eq)
   */
  private Integer quantityReceivedEq;
  /**
   * 到货量 比较(neq)
   */
  private Integer quantityReceivedNeq;
  /**
   * 到货量 比较(gt)
   */
  private Integer quantityReceivedGt;
  /**
   * 到货量 比较(gte)
   */
  private Integer quantityReceivedGte;
  /**
   * 到货量 比较(lt)
   */
  private Integer quantityReceivedLt;
  /**
   * 到货量 比较(lte)
   */
  private Integer quantityReceivedLte;
  /**
   * 到货量 比较(contains)
   */
  private Integer quantityReceivedContains;
  /**
   * 到货量 比较(notcontains)
   */
  private Integer quantityReceivedNotcontains;
  /**
   * 到货量 比较(startswith)
   */
  private Integer quantityReceivedStartswith;
  /**
   * 到货量 比较(endswith)
   */
  private Integer quantityReceivedEndswith;
  /**
   * 到货量 比较(isnull)
   */
  private Boolean quantityReceivedIsnull;
  /**
   * 到货量 比较(isnotnull)
   */
  private Boolean quantityReceivedIsnotnull;

  /**
   * 采购金额
   */
  private java.math.BigDecimal purchaseMoney;

  /**
   * 最小采购金额
   */
  private java.math.BigDecimal purchaseMoneyMin;

  /**
   * 最大采购金额
   */
  private java.math.BigDecimal purchaseMoneyMax;

  /**
   * 采购金额 比较(eq)
   */
  private java.math.BigDecimal purchaseMoneyEq;
  /**
   * 采购金额 比较(neq)
   */
  private java.math.BigDecimal purchaseMoneyNeq;
  /**
   * 采购金额 比较(gt)
   */
  private java.math.BigDecimal purchaseMoneyGt;
  /**
   * 采购金额 比较(gte)
   */
  private java.math.BigDecimal purchaseMoneyGte;
  /**
   * 采购金额 比较(lt)
   */
  private java.math.BigDecimal purchaseMoneyLt;
  /**
   * 采购金额 比较(lte)
   */
  private java.math.BigDecimal purchaseMoneyLte;
  /**
   * 采购金额 比较(contains)
   */
  private java.math.BigDecimal purchaseMoneyContains;
  /**
   * 采购金额 比较(notcontains)
   */
  private java.math.BigDecimal purchaseMoneyNotcontains;
  /**
   * 采购金额 比较(startswith)
   */
  private java.math.BigDecimal purchaseMoneyStartswith;
  /**
   * 采购金额 比较(endswith)
   */
  private java.math.BigDecimal purchaseMoneyEndswith;
  /**
   * 采购金额 比较(isnull)
   */
  private Boolean purchaseMoneyIsnull;
  /**
   * 采购金额 比较(isnotnull)
   */
  private Boolean purchaseMoneyIsnotnull;

  /**
   * 到货金额
   */
  private java.math.BigDecimal aogMoney;

  /**
   * 最小到货金额
   */
  private java.math.BigDecimal aogMoneyMin;

  /**
   * 最大到货金额
   */
  private java.math.BigDecimal aogMoneyMax;

  /**
   * 到货金额 比较(eq)
   */
  private java.math.BigDecimal aogMoneyEq;
  /**
   * 到货金额 比较(neq)
   */
  private java.math.BigDecimal aogMoneyNeq;
  /**
   * 到货金额 比较(gt)
   */
  private java.math.BigDecimal aogMoneyGt;
  /**
   * 到货金额 比较(gte)
   */
  private java.math.BigDecimal aogMoneyGte;
  /**
   * 到货金额 比较(lt)
   */
  private java.math.BigDecimal aogMoneyLt;
  /**
   * 到货金额 比较(lte)
   */
  private java.math.BigDecimal aogMoneyLte;
  /**
   * 到货金额 比较(contains)
   */
  private java.math.BigDecimal aogMoneyContains;
  /**
   * 到货金额 比较(notcontains)
   */
  private java.math.BigDecimal aogMoneyNotcontains;
  /**
   * 到货金额 比较(startswith)
   */
  private java.math.BigDecimal aogMoneyStartswith;
  /**
   * 到货金额 比较(endswith)
   */
  private java.math.BigDecimal aogMoneyEndswith;
  /**
   * 到货金额 比较(isnull)
   */
  private Boolean aogMoneyIsnull;
  /**
   * 到货金额 比较(isnotnull)
   */
  private Boolean aogMoneyIsnotnull;

  /**
   * 应付金额
   */
  private java.math.BigDecimal amountPayable;

  /**
   * 最小应付金额
   */
  private java.math.BigDecimal amountPayableMin;

  /**
   * 最大应付金额
   */
  private java.math.BigDecimal amountPayableMax;

  /**
   * 应付金额 比较(eq)
   */
  private java.math.BigDecimal amountPayableEq;
  /**
   * 应付金额 比较(neq)
   */
  private java.math.BigDecimal amountPayableNeq;
  /**
   * 应付金额 比较(gt)
   */
  private java.math.BigDecimal amountPayableGt;
  /**
   * 应付金额 比较(gte)
   */
  private java.math.BigDecimal amountPayableGte;
  /**
   * 应付金额 比较(lt)
   */
  private java.math.BigDecimal amountPayableLt;
  /**
   * 应付金额 比较(lte)
   */
  private java.math.BigDecimal amountPayableLte;
  /**
   * 应付金额 比较(contains)
   */
  private java.math.BigDecimal amountPayableContains;
  /**
   * 应付金额 比较(notcontains)
   */
  private java.math.BigDecimal amountPayableNotcontains;
  /**
   * 应付金额 比较(startswith)
   */
  private java.math.BigDecimal amountPayableStartswith;
  /**
   * 应付金额 比较(endswith)
   */
  private java.math.BigDecimal amountPayableEndswith;
  /**
   * 应付金额 比较(isnull)
   */
  private Boolean amountPayableIsnull;
  /**
   * 应付金额 比较(isnotnull)
   */
  private Boolean amountPayableIsnotnull;

  /**
   * 退货金额
   */
  private java.math.BigDecimal salesReturnMoney;

  /**
   * 最小退货金额
   */
  private java.math.BigDecimal salesReturnMoneyMin;

  /**
   * 最大退货金额
   */
  private java.math.BigDecimal salesReturnMoneyMax;

  /**
   * 退货金额 比较(eq)
   */
  private java.math.BigDecimal salesReturnMoneyEq;
  /**
   * 退货金额 比较(neq)
   */
  private java.math.BigDecimal salesReturnMoneyNeq;
  /**
   * 退货金额 比较(gt)
   */
  private java.math.BigDecimal salesReturnMoneyGt;
  /**
   * 退货金额 比较(gte)
   */
  private java.math.BigDecimal salesReturnMoneyGte;
  /**
   * 退货金额 比较(lt)
   */
  private java.math.BigDecimal salesReturnMoneyLt;
  /**
   * 退货金额 比较(lte)
   */
  private java.math.BigDecimal salesReturnMoneyLte;
  /**
   * 退货金额 比较(contains)
   */
  private java.math.BigDecimal salesReturnMoneyContains;
  /**
   * 退货金额 比较(notcontains)
   */
  private java.math.BigDecimal salesReturnMoneyNotcontains;
  /**
   * 退货金额 比较(startswith)
   */
  private java.math.BigDecimal salesReturnMoneyStartswith;
  /**
   * 退货金额 比较(endswith)
   */
  private java.math.BigDecimal salesReturnMoneyEndswith;
  /**
   * 退货金额 比较(isnull)
   */
  private Boolean salesReturnMoneyIsnull;
  /**
   * 退货金额 比较(isnotnull)
   */
  private Boolean salesReturnMoneyIsnotnull;

  /**
   * 实付金额
   */
  private java.math.BigDecimal actuallyPaid;

  /**
   * 最小实付金额
   */
  private java.math.BigDecimal actuallyPaidMin;

  /**
   * 最大实付金额
   */
  private java.math.BigDecimal actuallyPaidMax;

  /**
   * 实付金额 比较(eq)
   */
  private java.math.BigDecimal actuallyPaidEq;
  /**
   * 实付金额 比较(neq)
   */
  private java.math.BigDecimal actuallyPaidNeq;
  /**
   * 实付金额 比较(gt)
   */
  private java.math.BigDecimal actuallyPaidGt;
  /**
   * 实付金额 比较(gte)
   */
  private java.math.BigDecimal actuallyPaidGte;
  /**
   * 实付金额 比较(lt)
   */
  private java.math.BigDecimal actuallyPaidLt;
  /**
   * 实付金额 比较(lte)
   */
  private java.math.BigDecimal actuallyPaidLte;
  /**
   * 实付金额 比较(contains)
   */
  private java.math.BigDecimal actuallyPaidContains;
  /**
   * 实付金额 比较(notcontains)
   */
  private java.math.BigDecimal actuallyPaidNotcontains;
  /**
   * 实付金额 比较(startswith)
   */
  private java.math.BigDecimal actuallyPaidStartswith;
  /**
   * 实付金额 比较(endswith)
   */
  private java.math.BigDecimal actuallyPaidEndswith;
  /**
   * 实付金额 比较(isnull)
   */
  private Boolean actuallyPaidIsnull;
  /**
   * 实付金额 比较(isnotnull)
   */
  private Boolean actuallyPaidIsnotnull;

  /**
   * 未付金额
   */
  private java.math.BigDecimal unpaidMoney;

  /**
   * 最小未付金额
   */
  private java.math.BigDecimal unpaidMoneyMin;

  /**
   * 最大未付金额
   */
  private java.math.BigDecimal unpaidMoneyMax;

  /**
   * 未付金额 比较(eq)
   */
  private java.math.BigDecimal unpaidMoneyEq;
  /**
   * 未付金额 比较(neq)
   */
  private java.math.BigDecimal unpaidMoneyNeq;
  /**
   * 未付金额 比较(gt)
   */
  private java.math.BigDecimal unpaidMoneyGt;
  /**
   * 未付金额 比较(gte)
   */
  private java.math.BigDecimal unpaidMoneyGte;
  /**
   * 未付金额 比较(lt)
   */
  private java.math.BigDecimal unpaidMoneyLt;
  /**
   * 未付金额 比较(lte)
   */
  private java.math.BigDecimal unpaidMoneyLte;
  /**
   * 未付金额 比较(contains)
   */
  private java.math.BigDecimal unpaidMoneyContains;
  /**
   * 未付金额 比较(notcontains)
   */
  private java.math.BigDecimal unpaidMoneyNotcontains;
  /**
   * 未付金额 比较(startswith)
   */
  private java.math.BigDecimal unpaidMoneyStartswith;
  /**
   * 未付金额 比较(endswith)
   */
  private java.math.BigDecimal unpaidMoneyEndswith;
  /**
   * 未付金额 比较(isnull)
   */
  private Boolean unpaidMoneyIsnull;
  /**
   * 未付金额 比较(isnotnull)
   */
  private Boolean unpaidMoneyIsnotnull;

  /**
   * 申请中
   */
  private java.math.BigDecimal inApplication;

  /**
   * 最小申请中
   */
  private java.math.BigDecimal inApplicationMin;

  /**
   * 最大申请中
   */
  private java.math.BigDecimal inApplicationMax;

  /**
   * 申请中 比较(eq)
   */
  private java.math.BigDecimal inApplicationEq;
  /**
   * 申请中 比较(neq)
   */
  private java.math.BigDecimal inApplicationNeq;
  /**
   * 申请中 比较(gt)
   */
  private java.math.BigDecimal inApplicationGt;
  /**
   * 申请中 比较(gte)
   */
  private java.math.BigDecimal inApplicationGte;
  /**
   * 申请中 比较(lt)
   */
  private java.math.BigDecimal inApplicationLt;
  /**
   * 申请中 比较(lte)
   */
  private java.math.BigDecimal inApplicationLte;
  /**
   * 申请中 比较(contains)
   */
  private java.math.BigDecimal inApplicationContains;
  /**
   * 申请中 比较(notcontains)
   */
  private java.math.BigDecimal inApplicationNotcontains;
  /**
   * 申请中 比较(startswith)
   */
  private java.math.BigDecimal inApplicationStartswith;
  /**
   * 申请中 比较(endswith)
   */
  private java.math.BigDecimal inApplicationEndswith;
  /**
   * 申请中 比较(isnull)
   */
  private Boolean inApplicationIsnull;
  /**
   * 申请中 比较(isnotnull)
   */
  private Boolean inApplicationIsnotnull;

  /**
   * 未申请
   */
  private java.math.BigDecimal notApply;

  /**
   * 最小未申请
   */
  private java.math.BigDecimal notApplyMin;

  /**
   * 最大未申请
   */
  private java.math.BigDecimal notApplyMax;

  /**
   * 未申请 比较(eq)
   */
  private java.math.BigDecimal notApplyEq;
  /**
   * 未申请 比较(neq)
   */
  private java.math.BigDecimal notApplyNeq;
  /**
   * 未申请 比较(gt)
   */
  private java.math.BigDecimal notApplyGt;
  /**
   * 未申请 比较(gte)
   */
  private java.math.BigDecimal notApplyGte;
  /**
   * 未申请 比较(lt)
   */
  private java.math.BigDecimal notApplyLt;
  /**
   * 未申请 比较(lte)
   */
  private java.math.BigDecimal notApplyLte;
  /**
   * 未申请 比较(contains)
   */
  private java.math.BigDecimal notApplyContains;
  /**
   * 未申请 比较(notcontains)
   */
  private java.math.BigDecimal notApplyNotcontains;
  /**
   * 未申请 比较(startswith)
   */
  private java.math.BigDecimal notApplyStartswith;
  /**
   * 未申请 比较(endswith)
   */
  private java.math.BigDecimal notApplyEndswith;
  /**
   * 未申请 比较(isnull)
   */
  private Boolean notApplyIsnull;
  /**
   * 未申请 比较(isnotnull)
   */
  private Boolean notApplyIsnotnull;

  /**
   * 折扣金额
   */
  private java.math.BigDecimal discountAmount;

  /**
   * 最小折扣金额
   */
  private java.math.BigDecimal discountAmountMin;

  /**
   * 最大折扣金额
   */
  private java.math.BigDecimal discountAmountMax;

  /**
   * 折扣金额 比较(eq)
   */
  private java.math.BigDecimal discountAmountEq;
  /**
   * 折扣金额 比较(neq)
   */
  private java.math.BigDecimal discountAmountNeq;
  /**
   * 折扣金额 比较(gt)
   */
  private java.math.BigDecimal discountAmountGt;
  /**
   * 折扣金额 比较(gte)
   */
  private java.math.BigDecimal discountAmountGte;
  /**
   * 折扣金额 比较(lt)
   */
  private java.math.BigDecimal discountAmountLt;
  /**
   * 折扣金额 比较(lte)
   */
  private java.math.BigDecimal discountAmountLte;
  /**
   * 折扣金额 比较(contains)
   */
  private java.math.BigDecimal discountAmountContains;
  /**
   * 折扣金额 比较(notcontains)
   */
  private java.math.BigDecimal discountAmountNotcontains;
  /**
   * 折扣金额 比较(startswith)
   */
  private java.math.BigDecimal discountAmountStartswith;
  /**
   * 折扣金额 比较(endswith)
   */
  private java.math.BigDecimal discountAmountEndswith;
  /**
   * 折扣金额 比较(isnull)
   */
  private Boolean discountAmountIsnull;
  /**
   * 折扣金额 比较(isnotnull)
   */
  private Boolean discountAmountIsnotnull;

  /**
   * 采购员
   */
  private Long optUid;

  /**
   * 采购员 比较(eq)
   */
  private Long optUidEq;
  /**
   * 采购员 比较(neq)
   */
  private Long optUidNeq;
  /**
   * 采购员 比较(gt)
   */
  private Long optUidGt;
  /**
   * 采购员 比较(gte)
   */
  private Long optUidGte;
  /**
   * 采购员 比较(lt)
   */
  private Long optUidLt;
  /**
   * 采购员 比较(lte)
   */
  private Long optUidLte;
  /**
   * 采购员 比较(contains)
   */
  private Long optUidContains;
  /**
   * 采购员 比较(notcontains)
   */
  private Long optUidNotcontains;
  /**
   * 采购员 比较(startswith)
   */
  private Long optUidStartswith;
  /**
   * 采购员 比较(endswith)
   */
  private Long optUidEndswith;
  /**
   * 采购员 比较(isnull)
   */
  private Boolean optUidIsnull;
  /**
   * 采购员 比较(isnotnull)
   */
  private Boolean optUidIsnotnull;
  /**
   * 采购员的显示用户名 比较(eq)
   */
  private String optUidNameEq;
  /**
   * 采购员的显示用户名 比较(neq)
   */
  private String optUidNameNeq;
  /**
   * 采购员的显示用户名 比较(gt)
   */
  private String optUidNameGt;
  /**
   * 采购员的显示用户名 比较(gte)
   */
  private String optUidNameGte;
  /**
   * 采购员的显示用户名 比较(lt)
   */
  private String optUidNameLt;
  /**
   * 采购员的显示用户名 比较(lte)
   */
  private String optUidNameLte;
  /**
   * 采购员的显示用户名 比较(contains)
   */
  private String optUidNameContains;
  /**
   * 采购员的显示用户名 比较(notcontains)
   */
  private String optUidNameNotcontains;
  /**
   * 采购员的显示用户名 比较(startswith)
   */
  private String optUidNameStartswith;
  /**
   * 采购员的显示用户名 比较(endswith)
   */
  private String optUidNameEndswith;
  /**
   * 采购员的显示用户名 比较(isnull)
   */
  private Boolean optUidNameIsnull;
  /**
   * 采购员的显示用户名 比较(isnotnull)
   */
  private Boolean optUidNameIsnotnull;

  /**
   * 采购员(范围搜索)
   */
  private List<Long> optUidInList;

  /**
   * 备注(模糊搜索)
   */
  private String remarks;

  /**
   * 备注 比较(eq)
   */
  private String remarksEq;
  /**
   * 备注 比较(neq)
   */
  private String remarksNeq;
  /**
   * 备注 比较(gt)
   */
  private String remarksGt;
  /**
   * 备注 比较(gte)
   */
  private String remarksGte;
  /**
   * 备注 比较(lt)
   */
  private String remarksLt;
  /**
   * 备注 比较(lte)
   */
  private String remarksLte;
  /**
   * 备注 比较(contains)
   */
  private String remarksContains;
  /**
   * 备注 比较(notcontains)
   */
  private String remarksNotcontains;
  /**
   * 备注 比较(startswith)
   */
  private String remarksStartswith;
  /**
   * 备注 比较(endswith)
   */
  private String remarksEndswith;
  /**
   * 备注 比较(isnull)
   */
  private Boolean remarksIsnull;
  /**
   * 备注 比较(isnotnull)
   */
  private Boolean remarksIsnotnull;

  /**
   * 备注(精确搜索)
   */
  private List<String> remarksInList;

  /**
   * 是否有 附件
   */
  private Boolean files;

  /**
   * 目标表ID列(模糊搜索)
   */
  private String purchaseOrderId;

  /**
   * 目标表ID列 比较(eq)
   */
  private String purchaseOrderIdEq;
  /**
   * 目标表ID列 比较(neq)
   */
  private String purchaseOrderIdNeq;
  /**
   * 目标表ID列 比较(gt)
   */
  private String purchaseOrderIdGt;
  /**
   * 目标表ID列 比较(gte)
   */
  private String purchaseOrderIdGte;
  /**
   * 目标表ID列 比较(lt)
   */
  private String purchaseOrderIdLt;
  /**
   * 目标表ID列 比较(lte)
   */
  private String purchaseOrderIdLte;
  /**
   * 目标表ID列 比较(contains)
   */
  private String purchaseOrderIdContains;
  /**
   * 目标表ID列 比较(notcontains)
   */
  private String purchaseOrderIdNotcontains;
  /**
   * 目标表ID列 比较(startswith)
   */
  private String purchaseOrderIdStartswith;
  /**
   * 目标表ID列 比较(endswith)
   */
  private String purchaseOrderIdEndswith;
  /**
   * 目标表ID列 比较(isnull)
   */
  private Boolean purchaseOrderIdIsnull;
  /**
   * 目标表ID列 比较(isnotnull)
   */
  private Boolean purchaseOrderIdIsnotnull;

  /**
   * 目标表ID列(精确搜索)
   */
  private List<String> purchaseOrderIdInList;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
